home *** CD-ROM | disk | FTP | other *** search
Notes {labels: 'NIL, viewFont: 10241} // nil=Unfiled, or specify a folder, e.g., 'Business. remove viewFont for current Styles default //ERASE! remove initial // to erase existing entries in this folder first life.nwt -- Slurpee format 1/1/96 Copyright 1994-96. S. Weyer. All Rights Reserved Worldwide. Newt source (verson 1.4) for "the game of Life" See life.txt & online help book for description (optional) life.bit for Bitmaps: LifeIcon (optional) LifeCnst.pkg plug-in for native methods ("arrN", "bitN") ---------- init func() begin // several constants :DefConst('kFirstRowCol,1000); :DefConst('kLastRowCol,-1); end ---------- Life //:doObj('add, 'Life) //:doObj('remove, 'Life) //:doObj('build, 'Life) {// the main Life application viewClass: clView, viewBounds: NIL, // computed in viewSetupFormScript viewFlags: 4, // vApplication viewFormat: 337, // vfFillWhite + vfFrameBlack + vfPen*1, declareSelf: 'base, // for close box title: "Life 1.4", // sizeX can be <= 30. others computed in viewSetupFormScript sizeX: 26, // initial width of universe. right bits of a longint to use [ <= 30] // value of sizeX should also be included in xSizes list (see gridPicker) // these are computed from sizeX at run-time in viewSetupFormScript sizeY: NIL, // height of universe. cellSize: NIL, // size of a cell. maximize for screen width (maxAppWidth DIV sizeX) vSizeX: NIL, // width of drawing view (cellSize*sizeX) [<= maxAppWidth] vSizeY: NIL, // height of drawing view offsetX: NIL, // number of bit columns on left to skip (sizeX-32 *cellSize) maxAppWidth: NIL, maxDrawHeight: NIL, firstRow: NIL, // to avoid dead rows above lastRow: NIL, // to avoid dead rows below firstCol: NIL, // ditto for columns lastCol: NIL, pattern: NIL, // defaults to dot. set by patternPicker nGen: 0, // number of generations (clear =0, nextGeneration +1) universe: NIL, // representation of cells (array or bitmap) curMethod: 0, // arr*,arrI,arrN,bit,bitI,bitN. set by methodPicker kDrawTop: 20, // extra space above drawArea (for title, gridPicker) kDrawBot: 35, // below (for patternPicker, genPicker, status) viewSetupFormScript: func() begin self.Life := self; // for run-time access (rather than :parent()) GetRoot().ExtrasDrawer:?close(); // get it out of the way. save a little heap local ht, ap:= GetAppParams(); // configure to use entire current MP screen size self.viewBounds := RelBounds( ap.AppAreaLeft,ap.AppAreaTop, maxAppWidth := ap.AppAreaWidth, ht := ap.AppAreaHeight); maxDrawHeight := ht - kDrawTop - kDrawBot; stopped := true; :setGrid(sizeX,nil); end, setGrid: func(x,redo) // intialize or resize drawing area begin universe := NIL; sizeX := x; cellSize := maxAppWidth DIV sizeX; sizeY := maxDrawHeight DIV cellSize; vSizeX := cellSize * sizeX; // <= maxAppWidth. if sizeX divided evenly, no border vSizeY := cellSize * sizeY; // <= maxDrawHeight offsetX := (sizeX-32) * cellSize; // left bits not shown :clear(); if redo then :RedoChildren(); end, clear: func() begin :setUniverse(:makeUniverse()); nGen := 0; firstRow := firstCol := kFirstRowCol; // all empty lastRow := lastCol := kLastRowCol; if drawArea exists then drawArea:?Dirty(); // redraw next idle via viewDrawScript end, makeUniverse: func() Array(sizeY, 0), // leave rows 0 until needed setUniverse: func(u) universe := u, _package: { icon: :GetPictAsBits("Bitmaps","LifeIcon"), // comment out if life.bit not transferred }, } ---------- Life.init1~ {// this gets added to app frame but a little easier for editing if it's separate helpBook: :helpBookTemplate(), // copy data structure from Newt at development-time // actual help pages are added later, i.e., Life.helpBook+page1, etc. helpView: NIL, viewQuitScript: func() begin if helpView then helpView:close(); helpView := universe := NIL; end, // to support Rotate for Newton OS 2.0 //reorienting: NIL, ReorientToScreen: func() begin //reorienting := TRUE; :SyncView(); :RedoChildren(); //reorienting := NIL; end, } ---------- Life.idleStuff~ {// some additional Life methods/slots related to idling ("Repeat") updateGen: TRUE, // to refresh gen counter during Repeat (default). set via genPicker nCount: NIL, // num of gen for timing tests. e.g., 40. set by genPicker viewIdleScript: func() if not stopped then begin if :nextGeneration() // generate then begin drawArea:drawDots(true); if updateGen then genPicker:updateText(NumberStr(nGen)); end; if firstRow < kFirstRowCol and (not nCount or nGen < nCount) then delayMSecs // reschedule else status.repeatButton:stop(nil); // empty universe. NIL end, delayMsecs: 5, // allow a few milliseconds for taps (e.g., Stop, Clear, Gen:) stopped: TRUE, } ---------- Life.arr~ {// these are added to app frame. also "copied" into _arr later // use an array for representation, draw dots explicitly //drawDots -- defined separately getCell: func(row,x) if row=0 // or x < 0 or x >= sizeX then 0 else row[x], getRow: func(univ,y) univ[y], getUniverse: func() universe, // makeUniverse -- defined earlier // nextGeneration -- defined separately setCell: func(row,x,b) begin if row=0 then row := Array(sizeX, 0); row[x] := if b then b else 1 - row[x]; row; end, setRow: func(univ,y,row) univ[y] := row, // setUniverse -- defined earlier } ---------- Life.drawDots func(idle) if idle then :dirty() // let viewDrawScript do it else if firstRow < kFirstRowCol then begin local drawMode := '{ // for ovals transferMode: 0, // modeCopy fillPattern: 5, // vfFillBlack }; local y,row,y1,y2,x,x1; for y := firstRow to lastRow do if isArray(row := universe[y]) // :getRow(universe,y) then begin y1 := y*cellSize; y2 := y1+cellSize; // constant for row for x := firstCol to lastCol do if row[x]>0 // :getCell(row,x) then begin x1 := (sizeX-x-1)*cellSize; :DrawShape(MakeOval(x1,y1,x1+cellSize,y2),drawMode); end; end; end ---------- Life.setCells func(row,x,vals,start,count) // generic version used by drawArea.viewGestureScript begin local vx, vlen := 0, fill := 0; if isArray(vals) then vlen := Length(vals) else fill := vals; for vx := start to start+count-1 do row := :setCell(row,x-vx,if vx < vlen then vals[vx] else fill); row; end ---------- Life.nextGeneration func() // generic method (used by "arr" & "bit") if firstRow < kFirstRowCol // only bother if there are some cells then begin local univ := :getUniverse(); // existing local newuniv := :makeUniverse(); // new, empty universe local x, y, neighbors, frx, lrx; local frow := firstRow-1, lrow := lastRow+1; if frow<0 then frow := 0; if lrow >= sizeY then lrow := sizeY-1; local fcol := firstCol-1, lcol := lastCol+1; if fcol<0 then fcol := 0; if lcol >= sizeX then lcol := sizeX-1; local newFirstRow := kFirstRowCol, newLastRow := kLastRowCol; local newFirstCol := kFirstRowCol, newLastCol := kLastRowCol; local n1, n2, n3; // in this layout visually. local n4, n5, n6; local n7, n8, n9; local row1 := 0 , row2 := 0, newRow := 0; local row3 := :getRow(univ,frow); // process from top to bottom, from right to left for y := frow to lrow // skip some dead rows before/after active area do begin row1 := row2; row2 := row3; row3 := if y<lrow then :getRow(univ,y+1) else 0; if row1<>0 or row2<>0 or row3<>0 then begin // this optimizes for empty row(s) frx := kFirstRowCol; lrx := kLastRowCol; n1 := :getCell(row1,fcol); n4 := :getCell(row2,fcol); n7 := :getCell(row3,fcol); newRow := n2 := n5 := n8 := n3 := n6 := n9 := 0; for x := fcol to lcol // skip some dead columns after/before active area do begin if row1<>0 then begin n3 := n2; n2 := n1; n1 := if x=lcol then 0 else :getCell(row1,x+1); neighbors := n1+n2+n3; end else neighbors := 0; if row2<>0 then begin n6 := n5; n5 := n4; n4 := if x=lcol then 0 else :getCell(row2,x+1); neighbors := neighbors + n4+n6; // omit center end; if row3<>0 then begin n9 := n8; n8 := n7; n7 := if x=lcol then 0 else :getCell(row3,x+1); neighbors := neighbors + n7+n8+n9; end; if neighbors=3 or (neighbors=2 and n5=1) then begin newRow := :setCell(newRow,x,1); if x < frx then frx := x; // 1st(min) lrx := x; end; end; if lrx > kLastRowCol // something set in row? then begin :setRow(newuniv,y,newRow); newLastRow := y; // last(max) if y < newFirstRow then newFirstRow := y; // 1st(min) if frx < newFirstCol then newFirstCol := frx; // min if lrx > newLastCol then newLastCol := lrx; // max end; end; end; firstRow := newFirstRow; lastRow := newLastRow; firstCol := newFirstCol; lastCol := newLastCol; :setUniverse(newuniv); nGen := nGen+1; // <true> // refresh done via viewIdleScript or Next end ---------- Life+drawArea {// a drawing area (stepchild of Life) viewClass: clView, viewFlags: 2561, // vVisible + vClickable + vGesturesAllowed viewJustify: 16, // vjParentCenterH + vjParentTopV viewFormat: 337, // vfFillWhite + vfFrameBlack + vfPen*1, viewSetupFormScript: func() self.viewBounds := RelBounds(0,kDrawTop,vSizeX,vSizeY), viewDrawScript: func() begin // this is only invoked via :dirty (and it's stopped) :drawDots(nil); // (re)defined by arr/bit if stopped then begin // draw grid local x, y; local drawMode := '{ // for lines penSize: 1, penPattern: 3, // vfGray }; for y := cellSize to vSizeY-cellSize by cellSize // horizontal lines do :DrawShape(MakeLine(0,y,vSizeX,y), drawMode); for x := cellSize-1 to vSizeX-cellSize by cellSize // vertical lines do :DrawShape(MakeLine(x,0,x,vSizeY), drawMode); if updateGen and genPicker exists // might not during very initial build then genPicker:updateText(NumberStr(nGen)); end; end, } ---------- Life.drawArea.viewGestureScript func(unit, gestureID) begin local gb := :GlobalBox(), univ := :getUniverse(); local sb := StrokeBounds(unit); local ylen := if pattern then Length(pattern) else 0; // convert to local, grid coordinates. flip x local maxX := sizeX-1, maxY := sizeY-1; local x1 := maxX - max(0, (sb.left - gb.left) div cellSize); local y1 := max(0, (sb.top - gb.top) div cellSize); local x2 := maxX - min(maxX, (sb.right - gb.left) div cellSize); local y2 := min(maxY, (sb.bottom - gb.top) div cellSize); local xlen := x1-x2+1, y, fill := 0; if gestureID=13 or // aeScrub (gestureID=16 and fill:=1) // aeLine then for y := y1 to y2 // fill area do :setRow(univ,y, :setCells(:getRow(univ,y),x1, fill,0,xlen)) else if ylen>0 then begin // copy a pattern if y2+ylen > sizeY then ylen := sizeY - y2; // clip pattern at bottom y2 := y2 + ylen - 1; xlen := Length(pattern[0]); // note: uses length of first row as max width of pattern if x2-xlen < -1 then xlen := x2+1; // clip pattern at right x2 := x2 - xlen + 1; for y := 0 to ylen-1 do :setRow(univ, y+y1, :setCells(:getRow(univ,y+y1),x1, pattern[y],0,xlen)); end else // toggle single cell :setRow(univ,y1, :setCell(:getRow(univ,y1),x1,NIL)); // expand live area if y1 < firstRow then firstRow := y1; if y2 > lastRow then lastRow := y2; if x2 < firstCol then firstCol := x2; if x1 > lastCol then lastCol := x1; :Dirty(); // returns true end ---------- Life._arr {// this is the default version, so just copy the built-in versions drawDots: Life.drawDots, getCell: Life.getCell, getRow: Life.getRow, getUniverse: Life.getUniverse, makeUniverse: Life.makeUniverse, nextGeneration: Life.nextGeneration, setCell: Life.setCell, setRow: Life.setRow, setUniverse: Life.setUniverse, } ---------- Life._arrI {// same as _arr, but nextGeneration inlined drawDots: _arr.drawDots, getCell: _arr.getCell, getRow: _arr.getRow, getUniverse: _arr.getUniverse, makeUniverse: _arr.makeUniverse, nextGeneration: _arr.nextGeneration, // redefine (next) setCell: _arr.setCell, setRow: _arr.setRow, setUniverse: _arr.setUniverse, } ---------- Life._arrN {// same as _arr but nextGeneration native drawDots: _arr.drawDots, getCell: _arr.getCell, getRow: _arr.getRow, getUniverse: _arr.getUniverse, makeUniverse: _arr.makeUniverse, nextGeneration: if arrN_nextGeneration exists then arrN_nextGeneration else _arr.nextGeneration, setCell: _arr.setCell, setRow: _arr.setRow, setUniverse: _arr.setUniverse, } ---------- Life._arrI.nextGeneration func() // inlined version. ("arrN" adds INT,ARRAY declarations) if firstRow < kFirstRowCol then begin local univ := universe; local newuniv := Array(sizeY,0); local x, y, neighbors, frx, lrx; local frow := firstRow-1, lrow := lastRow+1; if frow<0 then frow := 0; if lrow >= sizeY then lrow := sizeY-1; local fcol := firstCol-1, lcol := lastCol+1; if fcol<0 then fcol := 0; if lcol >= sizeX then lcol := sizeX-1; local newFirstRow := kFirstRowCol, newLastRow := kLastRowCol; local newFirstCol := kFirstRowCol, newLastCol := kLastRowCol; local n1, n2, n3; local n4, n5, n6; local n7, n8, n9; local row1 := 0 , row2 := 0, newRow := 0; local row3 := univ[frow]; for y := frow to lrow do begin row1 := row2; row2 := row3; row3 := if y<lrow then univ[y+1] else 0; if row1<>0 or row2<>0 or row3<>0 then begin frx := kFirstRowCol; lrx := kLastRowCol; n1 := if row1=0 then 0 else row1[fcol]; n4 := if row2=0 then 0 else row2[fcol]; n7 := if row3=0 then 0 else row3[fcol]; newRow := n2 := n5 := n8 := n3 := n6 := n9 := 0; for x := fcol to lcol do begin if row1<>0 then begin n3 := n2; n2 := n1; n1 := if x=lcol or row1=0 then 0 else row1[x+1]; neighbors := n1+n2+n3; end else neighbors := 0; if row2<>0 then begin n6 := n5; n5 := n4; n4 := if x=lcol or row2=0 then 0 else row2[x+1]; neighbors := neighbors + n4+n6; end; if row3<>0 then begin n9 := n8; n8 := n7; n7 := if x=lcol or row3=0 then 0 else row3[x+1]; neighbors := neighbors + n7+n8+n9; end; if neighbors=3 or (neighbors=2 and n5=1) then begin if newRow=0 then newRow := Array(sizeX, 0); newRow[x] := 1; if x < frx then frx := x; lrx := x; end; end; if lrx > kLastRowCol then begin newuniv[y] := newRow; newLastRow := y; if y < newFirstRow then newFirstRow := y; if frx < newFirstCol then newFirstCol := frx; if lrx > newLastCol then newLastCol := lrx; end; end; end; firstRow := newFirstRow; lastRow := newLastRow; firstCol := newFirstCol; lastCol := newLastCol; universe := newuniv; nGen := nGen+1; end ---------- Life._bit {// use a bitmap representation drawDots: func(idle) // this is sent to drawArea from viewIdleScript or viewDrawScript :copyBits(universe, offsetX, 0, nil), getCell: func(row,x) // return a bit: 0 or 1 // left shifting sign bit (x=29) fills 1's (so usually test first) if row=0 //or x >= sizeX then 0 else BAND(row >> x, 1), // 0 <= x < sizeX. 0 on right getRow: func(bits,y) // return a row (30-bit integer) in bitmap. 0<=y<sizeY ExtractLong(bits, 16 + (y*4)), getUniverse: func() // return current bitmap universe.bits, makeUniverse: func() begin // initialize a new bitmap local myBits := SetLength(Clone("\u00000000000000000000000000000000"), 16 + (4 * sizeY)); //rowBytes*pixelHeight SetClass (myBits,'bits); StuffWord(myBits, 4, 4); // rowBytes StuffWord(myBits, 12, sizeY); // pixelHeight StuffWord(myBits, 14, 32); // pixelWidth myBits; end, nextGeneration: Life.nextGeneration, // generic version. same as _arr.nextGeneration setCell: func(row,x,b) // set a bit to 0 or 1 (or NIL=toggle) & return new row begin // [used only by viewClickScript currently] local bit1 := 1 << x; // 0 <= x < sizeX. 0 on right if row=0 and b<>0 // 1, NIL then bit1 else if (if b then b=0 else BAND(row, bit1) <> 0) then BAND(row, BNOT(bit1)) // :=0 else BOR(row, bit1); // :=1 end, setRow: func(bits,y,row) // replace a row (30-bit integer) in bitmap StuffLong(bits, 16 + (y*4), row), setUniverse: func(u) // set current bitmap if isFrame(universe) then universe.bits := u else universe := { // a bitmap frame bounds: RelBounds(0, 0, 32*cellSize, vSizeY), bits: u, // reset this each generation }, } ---------- Life._bitI {// keep copies of refs drawDots: _bit.drawDots, getCell: _bit.getCell, getRow: _bit.getRow, getUniverse: _bit.getUniverse, makeUniverse: _bit.makeUniverse, nextGeneration: _bit.nextGeneration, // redefine (next) setCell: _bit.setCell, setRow: _bit.setRow, setUniverse: _bit.setUniverse, } ---------- Life._bitN {// same as bit but with two native methods from plug-in LifeConst:TKnollSys // nextGeneration and makeUniverse have some declarations and provide most of the benefit drawDots: _bit.drawDots, getCell: _bit.getCell, getRow: _bit.getRow, getUniverse: _bit.getUniverse, makeUniverse: if bitN_makeUniverse exists then bitN_makeUniverse else _bit.makeUniverse, nextGeneration: if bitN_nextGeneration exists then bitN_nextGeneration else _bit.nextGeneration, setCell: _bit.setCell, setRow: _bit.setRow, setUniverse: _bit.setUniverse, } ---------- Life._bitI.nextGeneration func() // inline version. ("bitN" adds INT declarations) if firstRow < kFirstRowCol then begin local univ := universe.bits; local newuniv := :makeUniverse(); // following locals are INT in native (bitN) version local x, y, neighbors, frx, lrx; local frow := firstRow-1, lrow := lastRow+1; if frow<0 then frow := 0; if lrow >= sizeY then lrow := sizeY-1; local fcol := firstCol-1, lcol := lastCol+1; if fcol<0 then fcol := 0; if lcol >= sizeX then lcol := sizeX-1; local newFirstRow := kFirstRowCol, newLastRow := kLastRowCol; local newFirstCol := kFirstRowCol, newLastCol := kLastRowCol; local n1, n2, n3; local n4, n5, n6; local n7, n8, n9; local row1 := 0 , row2 := 0, newRow := 0; local row3 := ExtractLong(univ, 16 + (frow*4)); for y := frow to lrow do begin row1 := row2; row2 := row3; row3 := if y<lrow then ExtractLong(univ, 16 + (y+1)*4) else 0; if row1<>0 or row2<>0 or row3<>0 then begin frx := kFirstRowCol; lrx := kLastRowCol; n1 := BAND(row1 >> fcol, 1); n4 := BAND(row2 >> fcol, 1); n7 := BAND(row3 >> fcol, 1); newRow := n2 := n5 := n8 := n3 := n6 := n9 := 0; for x := fcol to lcol do begin if row1<>0 then begin n3 := n2; n2 := n1; n1 := if x=lcol or row1=0 then 0 else BAND(row1 >> (x+1), 1); neighbors := n1+n2+n3; end else neighbors := 0; if row2<>0 then begin n6 := n5; n5 := n4; n4 := if x=lcol then 0 else BAND(row2 >> (x+1), 1); neighbors := neighbors + n4+n6; end; if row3<>0 then begin n9 := n8; n8 := n7; n7 := if x=lcol then 0 else BAND(row3 >> (x+1), 1); neighbors := neighbors + n7+n8+n9; end; if neighbors=3 or (neighbors=2 and n5=1) then begin newRow := BOR(newRow, 1 << x); if x < frx then frx := x; lrx := x; end; end; if lrx > kLastRowCol then begin StuffLong(newuniv, 16 + (y*4), newRow); newLastRow := y; if y < newFirstRow then newFirstRow := y; if frx < newFirstCol then newFirstCol := frx; if lrx > newLastCol then newLastCol := lrx; end; end; end; firstRow := newFirstRow; lastRow := newLastRow; firstCol := newFirstCol; lastCol := newLastCol; universe.bits := newuniv; nGen := nGen+1; end ---------- Life+titleObj {// title at top (displays Life.title) _proto: protoTitle, } ---------- Life+gridPicker {// a picker for choosing size of grid _proto: protoLabelPicker, text: "grid", viewBounds: RelBounds(1,1,100,14), xSizes: [30,26,24,20,16,12], // some convenient sizes. max 30. include original sizeX labelActionScript: func(i) Life:setGrid(xSizes[i],true), textSetup: func() // current size (sizeX had better be in list) labelCommands[SetContains(xSizes,sizeX)], viewSetupFormScript: func() begin local xsize; self.labelCommands := foreach xsize in xSizes // e.g., 30x35 collect xsize & "x" & maxDrawHeight DIV (maxAppWidth DIV xsize); inherited:?viewSetupFormScript(); end, } ---------- Life+methodPicker {// a picker for chooosing various representation/display methods _proto: protoLabelPicker, text: "method", viewBounds: RelBounds(-87,1,86,14), labelCommands: ["Arr", "ArrI", "ArrN", "Bit", "BitI", "BitN",], viewJustify: 32, // vjParentRightH labelActionScript: func(i) begin // splice in different versions of methods curMethod := i; local msg, meths := Life.(Intern("_" & labelCommands[i])); foreach msg in '[ drawDots, getCell, getRow, getUniverse, makeUniverse, nextGeneration, setCell, setRow, setUniverse] do Life.(msg) := meths.(msg); :clear(); end, textSetup: func() labelCommands[curMethod], } ---------- Life+patternPicker {// a picker for pre-built patterns _proto: protoLabelPicker, viewBounds: RelBounds(1, -33, 135, 14), text: "pattern", viewJustify: 128 + 8388608, // vjParentBottomV + vjLeftH + oneLineOnly, patterns: [// order matches names in labelCommands NIL, // none=dot NIL, // menu pickseparator line -------- [[0,1,0,], // glider (note: 1st line of pattern should be max width (pad right with 0s if nec) [1,], // subsequent rows can omit trailing 0s [1,1,1,]], [[1,1,1,]], // blinker [[1,1], // block [1,1]], [[0,1,1,0,], // beehive [1,0,0,1,], [0,1,1,]], ], labelCommands: ["<dot>", 'pickSeparator, "glider", "blinker", "block", "beehive",], labelActionScript: func(i) pattern := patterns[i], // for copying in drawArea.viewGestureScript textSetup: func() // name of current pattern labelCommands[SetContains(patterns,pattern)], } ---------- Life+genPicker {// a "generation" count picker _proto: protoLabelPicker, text: "gen", viewBounds: RelBounds(-105,-33,104,14), // at right, just above status bar labelCommands: [ "0", // update current gen# (nGen) "<0>", // don't update "<time:40>", // don't update. do timing&stop at 40 "<time:100>", // don't udpate. do timing&stop at 100 ], viewJustify: 32+128,// vjParentRightH+vjParentBottomV labelActionScript: func(i) begin updateGen := i=0; nCount := if i = 2 then 40 else if i=3 then 100 else NIL; nGen := 0; end, textSetup: func() // name of current gen option labelCommands[ if ncount=40 then 2 else if ncount=100 then 3 else if updateGen then 0 else 1], } ---------- ButtonBounds func(width) // used for adding embedded buttons to status // this is defined as a Newt development-time method // once the buttons are initialized and added to status, // it really isn't needed anymore (and it isn't saved with the package) // also not needed if ViewCnst.pkg plug-in is used begin local left1:=25, top:=2, spacing:=6, bottom:=15; if width > 0 then SetBounds(spacing, top, spacing + width, bottom) // other buttons else SetBounds(left1, top, left1 - width, bottom); // first button end ---------- Life+status {// status bar with clock and closebox _proto: protoStatus, } ---------- Life.status+clearButton {_proto: protoTextButton, viewBounds: :ButtonBounds(-40), // first button (stepchild) in status area text: "Clear", buttonClickScript: func() Life:Delete('clear,[]), // built-in crumple/trash can effect } ---------- Life.status+nextButton {_proto: protoTextButton, viewBounds: :ButtonBounds(40), // second button viewJustify: 8389638, // vjParentLeftH + vjParentTopV + vjSiblingRightH + oneLineOnly + vjCenterH + vjCenterV, text: "Next", buttonClickScript: func() if stopped then begin :nextGeneration(); drawArea:dirty(); end, } ---------- Life.status+repeatButton {_proto: protoTextButton, viewBounds: :ButtonBounds(40), // third button viewJustify: 8389638, text: "Repeat", buttonClickScript: func() if firstRow < kFirstRowCol // not empty? then if stopped then begin // start up background process gc(); time1 := Ticks(); stopped := Life:setupIdle(delayMsecs); // start background process. NIL SetValue(self, 'text, "Stop"); end else :stop(true), stop: func(fl) begin // used to stop things from repeatButton.buttonClickScript or viewIdleScript if fl then Life:SetupIdle(0); // halt background process if nCount then begin Print("time:" && Ticks() - time1); nGen := 0; end; stopped := TRUE; SetValue(self, 'text, "Repeat"); drawArea:dirty(); // redraw with grid NIL; // turn off idling by returning nil end, time1: NIL, // for possible timing (if nCount non-nil) } ---------- Life.status+zhelpButton {_proto: protoTextButton, viewBounds: :ButtonBounds(40), // fourth button (zhelp sorts 4th) viewJustify: 8389638, text: "Info", buttonClickScript: func() if helpBook and stopped // open help book then begin local TT := GetRoot().TinyTim; // the help reader app if not helpView then helpView := BuildContext( {_proto: TT._proto, bookRef: helpBook}); TT:Close(); // in case system help is currently open helpView:openManual(helpBook); end, } ---------- Life.helpBook+page1 .# first help book page. this is much easier than dealing with BookMaker! .subject 1 Describe Life .story Life is a mathematical simulation game described by John Conway in Scientific American in Oct. 1970. Several rules are used to create a next generation from a cell's 8 neighbors: - Survival: A cell with 2 or 3 neighbors survives. - Death: A cell with 1 or less, or 4 or more neighbors, "dies". - Birth: An empty cell with exactly 3 neighbors will be "born". ---------- Life.helpBook+page2 .subject 1 Understand the Code .story This version of Life (1.4) has six variations/optimizations, which are explained in the file: life.txt. The article "Life with NewtonScript" by David Betz in Byte, March 1994, pp. 191-194 provides some introduction/background. You could also register for the Newt Development Environment (see Develop) to obtain a Newton programming manual and more NewtonScript application examples. ---------- Life.helpBook+page3 .subject 1 Distribute .story This version of Life is freeware and may be distributed freely as long as all of the files are included and unmodified. You are free to make modifications for your own use. Copyright 1994-96, S. Weyer. All Rights Reserved Worldwide. ---------- Life.helpBook+page4 .subject 1 Use .story \uFC01\u grid: grid size \uFC01\u method: computation method \uFC01\u pattern: fill pattern for <tap> \uFC01\u gen: turn on/off counter,timing <tap>: add a pattern, or toggle a cell <line>: fill an area <scrub>: erase an area [Clear]: clear all cells, reset Gen. counter [Next]: evolve a single generation [Repeat]: evolve until all cells are empty or you tap Stop or Clear [Info]: this help book ---------- Life.helpBook+page5 .subject 1 Develop .story If you are interested in object-oriented programming, developing applications in NewtonScript and saving as packages directly on your Newton, try the "Newt" development environment. Registered users receive a 80+ pp. manual (Acrobat or paper) and 190+ examples. For further info, see life.txt or http://www.netaxs.com/~weyer/newton/releases.html ---------- Life.helpBook+page6 .subject 1 Contact Author .story Steve Weyer 17 Timber Knoll Drive Washington Crossing, PA 18977-1052 Internet: weyer@netaxs.com America Online, eWorld, NewtonMail: SteveWeyer Compuserve: 74603,2051 http://www.netaxs.com/~weyer/newton/releases.html ---------- BYE! 
